home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / MM2_DEV / S / GEM / LINEA.D < prev    next >
Encoding:
Modula Definition  |  1990-10-09  |  25.5 KB  |  516 lines
  1. DEFINITION MODULE LineA;
  2.  
  3.  
  4. (*  Megamax Modula-2 Line-A-Routinen
  5.  *
  6.  *  Autor: Manuel Chakravarty
  7.  *
  8.  *  Created: 7.4.1987           Version 2.1   V#0069
  9.  *)
  10.  
  11.  
  12. (*
  13.  *      HINWEIS: Bei der Verwendung der Line-A-Routine ist eine gewisse Vor-
  14.  *               sicht geboten, da diese auf eventuellen Nachfolgermodellen
  15.  *               des Atari ST wahrscheinlich nicht mehr auf diese Weise unter-
  16.  *               stützt werden und darauf aufbauende Programme dann nicht
  17.  *               mehr lauffähig sein könnten.
  18.  *
  19.  *      Die Line-A-Routinen stellen die grundlegenden Ausgabemöglichkeiten
  20.  *      des ATARI ST dar. Mit ihrer Hilfe kann man sowohl Striche, wie auch
  21.  *      Zeichen auf den Bildschirm bannen. Das gesamte GEM ist auf diese
  22.  *      Routinen aufgesetzt, was natürlich bedingt, daß die Line-A-Funktionen
  23.  *      den VDI Routinen an Geschwindigkeit und Flexibilität überlegen sind.
  24.  *      Dafür sind sie weniger komplex und komfortabel.
  25.  *      Die Line-A-Prozeduren arbeiten auf den Line-A-Variablen, dies ist
  26.  *      ein statischer Variablenbereich, der ermittelt und manipuliert wer-
  27.  *      den kann. Diese Variablen enthalten einen Großteil der, für die
  28.  *      Routinen notwendigen, Parameter. Welche Variablen eine Routine aus-
  29.  *      wertet wird in ihrer Beschreibung angegeben.
  30.  *)
  31.  
  32.  
  33. FROM SYSTEM     IMPORT BYTE, WORD, ADDRESS;
  34.  
  35. FROM GrafBase   IMPORT WordBitSet, WritingMode, BitOperation, Point, Rectangle,
  36.                        PtrMouseFormDef, PtrMemFormDef;
  37.  
  38.  
  39. TYPE    PtrByteArray            = POINTER TO ARRAY[0..MaxCard] OF BYTE;
  40.         PtrIntArray             = POINTER TO ARRAY[0..MaxCard] OF INTEGER;
  41.         PtrCardArray            = POINTER TO ARRAY[0..MaxCard] OF CARDINAL;
  42.         
  43.         SystemFont              = (font6x6, font8x8, font8x16);
  44.         PtrFontHeader           = POINTER TO FontHeader;
  45.         FontHeader              = RECORD
  46.                                     id           : CARDINAL;
  47.                                     size         : INTEGER;
  48.                                     name         : ARRAY[0..31] OF CHAR;
  49.                                     minADE       : CARDINAL;
  50.                                     maxADE       : CARDINAL;
  51.                                     topToBase    : CARDINAL;
  52.                                     ascentToBase : CARDINAL;
  53.                                     halfToBase   : CARDINAL;
  54.                                     descentToBase: CARDINAL;
  55.                                     bottomToBase : CARDINAL;
  56.                                     maxCharWidth : CARDINAL;
  57.                                     maxBoxWidth  : CARDINAL;
  58.                                     leftOffset   : INTEGER;
  59.                                     rightOffset  : INTEGER;
  60.                                     thickening   : CARDINAL;
  61.                                     underLineH   : CARDINAL;
  62.                                     lightMask    : CARDINAL;
  63.                                     skewMask     : CARDINAL;
  64.                                     flags        : WordBitSet;
  65.                                     horOffsetTab : PtrIntArray;
  66.                                     charOffsetTab: PtrIntArray;
  67.                                     fontData     : PtrCardArray;
  68.                                     formWidth    : CARDINAL;
  69.                                     formHeight   : CARDINAL;
  70.                                     next         : PtrFontHeader;
  71.                                   END;
  72.         PtrSysFontHeader        = POINTER TO ARRAY SystemFont OF PtrFontHeader;
  73.         
  74.         (*  Definition der Line-A-Varaible.
  75.          *  Eine genauere Beschreibung ist im Handbuch zu finden.
  76.          *)
  77.         LineAVars               = RECORD
  78.                                     planes       : CARDINAL;
  79.                                     bytesPerLine : CARDINAL;
  80.                                     contrl       : PtrIntArray;
  81.                                     intin        : PtrIntArray;
  82.                                     ptsin        : PtrIntArray;
  83.                                     intout       : PtrIntArray;
  84.                                     ptsout       : PtrIntArray;
  85.                                     plane1       : BOOLEAN;
  86.                                     plane2       : BOOLEAN;
  87.                                     plane3       : BOOLEAN;
  88.                                     plane4       : BOOLEAN;
  89.                                     lastLine     : BOOLEAN;
  90.                                     lineMask     : CARDINAL;
  91.                                     writingMode  : WritingMode;
  92.                                     p            : Point;
  93.                                     q            : Point;
  94.                                     patternPtr   : PtrCardArray;
  95.                                     patternMask  : CARDINAL;
  96.                                     multiFill    : BOOLEAN;
  97.                                     clipping     : BOOLEAN;
  98.                                     minClip      : Point;
  99.                                     maxClip      : Point;
  100.                                     scaleAcc     : CARDINAL;
  101.                                     scaleFactor  : CARDINAL;
  102.                                     scaleMode    : WordBitSet;
  103.                                     monoStatus   : BOOLEAN;
  104.                                     source       : Point;
  105.                                     dest         : Point;
  106.                                     width        : CARDINAL;
  107.                                     height       : CARDINAL;
  108.                                     formBase     : PtrCardArray;
  109.                                     formWidth    : INTEGER;
  110.                                     style        : WordBitSet;
  111.                                     lightMask    : CARDINAL;
  112.                                     skewMask     : CARDINAL;
  113.                                     weight       : CARDINAL;
  114.                                     rightOff     : INTEGER;
  115.                                     leftOff      : INTEGER;
  116.                                     scale        : BOOLEAN;
  117.                                     chup         : CARDINAL;
  118.                                     textFg       : CARDINAL;
  119.                                     scratchArea  : PtrCardArray;
  120.                                     scratchOff2  : CARDINAL;
  121.                                     textBg       : CARDINAL;
  122.                                     copyTrans    : BOOLEAN;
  123.                                     seedAbort    : ADDRESS;
  124.                                   END;
  125.         PtrLineAVars            = POINTER TO LineAVars;
  126.         
  127.         NegLineAVars            = RECORD
  128.                                     
  129.                                     (*  Zeichenhöhe
  130.                                      *)
  131.                                     cellHeight   : CARDINAL;
  132.                                     
  133.                                     (*  Maximale Cursor Spalten- und Zeilen-
  134.                                      *  position.
  135.                                      *)
  136.                                     maxColumn    : CARDINAL;
  137.                                     maxRow       : CARDINAL;
  138.                                     
  139.                                     (*  Zeichenzeilenbreite in Bytes
  140.                                      *)
  141.                                     charRowWidth : CARDINAL;
  142.                                     
  143.                                     (*  Hinter- und Vordergrundfarbe
  144.                                      *)
  145.                                     bgColor      : CARDINAL;
  146.                                     fgColor      : CARDINAL;
  147.                                     
  148.                                     (*  Adresse der aktuellen Cursorposition
  149.                                      *)
  150.                                     cursAddr     : ADDRESS;
  151.                                     
  152.                                     (*  Vertikaler Offset zum Anfang des
  153.                                      *  Bildschirms. Siehe auch 'VDIEscapes.
  154.                                      *  SetLineOffset'.
  155.                                      *)
  156.                                     lineOffset   : INTEGER;
  157.                                     
  158.                                     (*  Spalten- und Zeilenposition des
  159.                                      *  Cursors
  160.                                      *)
  161.                                     cursColumn   : CARDINAL;
  162.                                     cursRow      : CARDINAL;
  163.                                     
  164.                                     (*  Blinkgeschw. des Cursors und Zähler
  165.                                      *  für das Cursorblinken.
  166.                                      *)
  167.                                     cursFrequence: BYTE;
  168.                                     cursCount    : BYTE;
  169.                                     
  170.                                     (*  Zeiger auf den Systemzeichensatz
  171.                                      *  Siehe auch 'VDIEscapes.InitSystemFont'.
  172.                                      *)
  173.                                     sysFontAddr  : ADDRESS;
  174.                                     
  175.                                     (*  ASCII-Wert des letzten und ersten
  176.                                      *  Zeichens im Systemzeichensatz und
  177.                                      *  Breite der Fontdaten in Bytes.
  178.                                      *)
  179.                                     maxADE       : CARDINAL;
  180.                                     minADE       : CARDINAL;
  181.                                     fontWidth    : CARDINAL;
  182.                                     
  183.                                     (*  Bildschirmbreite in Pixel
  184.                                      *)
  185.                                     screenWidth  : CARDINAL;
  186.                                     
  187.                                     (*  Zeiger auf die Offset-Tabelle des
  188.                                      *  Systemzeichensatzes.
  189.                                      *)
  190.                                     fontOffset   : ADDRESS;
  191.                                     
  192.                                     (*  Aktueller Cursorzustand:
  193.                                      *
  194.                                      *    b0 -- Cursorblinken ein/aus
  195.                                      *    b1 -- momentaner Cursorzustand
  196.                                      *          (normal/invertiert)
  197.                                      *    b2 -- Cursor unsichtbar/sichtbar
  198.                                      *    b3 -- Wrapping ein/aus
  199.                                      *    b4 -- Inverse Darstellung ein/aus
  200.                                      *    b5 -- Cursorposition gespeichert
  201.                                      *)
  202.                                     cursStatus   : WordBitSet;
  203.                                     
  204.                                     (*  Bildschirmhöhe in Pixel
  205.                                      *)
  206.                                     screenHeight : CARDINAL;
  207.                                     
  208.                                     (*  Breite einer Bildschirmzeile in Byte
  209.                                      *)
  210.                                     bytesPerLine : CARDINAL;
  211.                                     
  212.                                   END;
  213.         PtrNegLineAVars         = POINTER TO NegLineAVars;
  214.         
  215.  
  216. PROCEDURE SystemFonts (): PtrSysFontHeader;
  217.         
  218.         (*  Durch diese Funktion erhählt man einen Zeiger auf ein Feld,
  219.          *  in dem die Startaddressen der drei System-Font-Header gespei-
  220.          *  chert sind.
  221.          *)
  222.  
  223.  
  224. PROCEDURE LineAVariables (): PtrLineAVars;
  225.         
  226.         (*  Liefert einen Zeiger auf die Line-A-Variablen.
  227.          *)
  228.  
  229. PROCEDURE NegLineAVariables (): PtrNegLineAVars;
  230.         
  231.         (*  Liefert einen Zeiger auf die 'VDI-Escape-Variablen' (negative
  232.          *  Line-A-Variablen).
  233.          *
  234.          *  Die Benutzung dieser Variablen ist nicht uneingeschränkt zu
  235.          *  empfehlen, da ihre Lage von Atari nicht offiziell dokumen-
  236.          *  tiert ist. Da sie aber bei allen bisherigen TOS-Versionen
  237.          *  ihre Lage relativ zu den Line-A-Variablen nicht verändert
  238.          *  haben, ist ihre Benutzung relativ sicher.
  239.          *)
  240.  
  241.  
  242. PROCEDURE PutPixel (p: Point; color: CARDINAL);
  243.  
  244.         (*  Diese Routine weißt dem Punkt 'p' des logischen Bildschirms
  245.          *  die Farbe 'color' zu. Dabei wird weder das Clipping noch ei-
  246.          *  ne andere der Line-A-Variablen berücksichtigt.
  247.          *)
  248.         
  249. PROCEDURE PixelColor (p: Point): CARDINAL;
  250.  
  251.         (*  Ermittelt den Farbwert des Punktes 'p'.
  252.          *)
  253.  
  254. PROCEDURE Line (p, q: Point);
  255.  
  256.         (*  'Line' zieht eine Linie zwischen den beiden Punkten 'p' und
  257.          *  'q', dabei wird die Farbe durch die Line-A-Variablen 'plane1'
  258.          *  bis 'plane4' bestimmt, außerdem wird 'writingMode', 'lineMask'
  259.          *  und 'lastLine' berücksichtigt.
  260.          *)
  261.  
  262. PROCEDURE HorizontalLine (x1, x2, y: INTEGER);
  263.  
  264.         (*  Zieht eine horizontale Line von 'x1' bis 'x2' auf der Höhe von
  265.          *  'y', die Farbe wird wieder durch 'plane1' bis 'plane4' bestimmt
  266.          *  und es werden noch 'writingMode', 'patternPtr', 'patternMask'
  267.          *  und 'multiFill' berücksichtigt.
  268.          *)
  269.  
  270. PROCEDURE FilledRectangle (p, q: Point);
  271.  
  272.         (*  Diese Procedur zeichnet ein gefülltes Rechteck, dessen Ausmaße
  273.          *  durch 'p' und 'q' bestimmt werden, dabei ist 'p' der linke,
  274.          *  obere und 'q' der rechte, untere Eckpunkt. Die Parameter wer-
  275.          *  den durch die gleichen Line-A-Variablen, wie bei 'Horizontal-
  276.          *  Line' festgelegt, nur werden zusätzlich noch die Clippingvar-
  277.          *  iablen benutzt.
  278.          *)
  279.  
  280. PROCEDURE FilledPolygon (REF pts: ARRAY OF Point; noPts: CARDINAL; y: INTEGER);
  281.  
  282.         (*  Mit dieser Funktion kann man gefüllte Polygone zeichnen, aller-
  283.          *  dings wird bei einem einzelnen Aufruf noch nicht das gesamte
  284.          *  Polygon, sondern nur eine einzelne Zeile daraus gezeichnet.
  285.          *  Welche Zeile gezeichnet wird, gibt 'y' an. Um das vollständige
  286.          *  Vieleck zu erhalten, muß man also die oberste und unterste Bild-
  287.          *  schirmzeile ermitteln, in der das Polygon liegt; danach ruft
  288.          *  man 'FilledPolygon' für alle Zeilen, die zwischen der obersten
  289.          *  und untersten liegen auf. Das Feld 'pts' enthält alle Eckpunkte
  290.          *  des Vielecks, wobei der erste Punkt (pts[0]) noch einmal als
  291.          *  letzter auftretten muß. Wieviel effektive Eckpunkt das Polygon
  292.          *  besitzt, wird in 'noPts' angegeben. Ist 'noPts = 0', so wird das
  293.          *  gesamte Feld benutzt.
  294.          *  Die berücksichtigten Line-A-Variablen entsprechen denen von
  295.          *  'FilledRectangle'.
  296.          *)
  297.  
  298.  
  299. TYPE    BBTDeskriptor   = RECORD
  300.                             w            : CARDINAL;
  301.                             h            : CARDINAL;
  302.                             destPlanes   : CARDINAL;
  303.                             setBitCol    : CARDINAL;
  304.                             unsetBitCol  : CARDINAL;
  305.                             mode00       : BYTE;
  306.                             mode01       : BYTE;
  307.                             mode10       : BYTE;
  308.                             mode11       : BYTE;
  309.                             sourceStart  : Point;
  310.                             sourceAddr   : ADDRESS;
  311.                             sourceInc    : CARDINAL;
  312.                             sourceWidth  : CARDINAL;
  313.                             sourceWidth2 : CARDINAL;
  314.                             destStart    : Point;
  315.                             destAddr     : ADDRESS;
  316.                             destInc      : CARDINAL;
  317.                             destWidth    : CARDINAL;
  318.                             destWidth2   : CARDINAL;
  319.                             patternPtr   : PtrByteArray;
  320.                             patternWidth : CARDINAL;
  321.                             patPlaneOff  : CARDINAL;
  322.                             patternEnd   : CARDINAL;
  323.                             scratch      : ARRAY[0..11] OF WORD;
  324.                           END;
  325.         PtrBBTDeskriptor= POINTER TO BBTDeskriptor;
  326.  
  327. PROCEDURE BitBlockTransfer (deskriptor: PtrBBTDeskriptor);
  328.  
  329.         (*  Diese Routine kopiert Speicherbereiche, insbesondere Bild-
  330.          *  schirmausschnitte, wobei allerdings auch noch ein Füll-
  331.          *  muster als Maske verwendet werden kann. Falls ein Blitter
  332.          *  vorhanden und dieser auch aktiviert ist, so wird die ei-
  333.          *  gentliche Kopierarbeit an ihn übertragen, ist der Chip
  334.          *  nicht im Rechner eingebaut oder abgeschalten, so wird die
  335.          *  Aufgabe von einer Art Software-Blitter übernommen, wodurch
  336.          *  alles etwas langsamer, aber im Prinzip gleichartig abläuft.
  337.          *  Das Record, auf das 'deskriptor' zeigt, beschreibt den Ko-
  338.          *  pierauftrag vollständig, es werden also keine Line-A-Var-
  339.          *  iablen benutzt.
  340.          *)
  341.  
  342. PROCEDURE TextBlockTransfer (font: PtrFontHeader; ch: CHAR; spot: Point);
  343.         
  344.         (*  Gibt das Zeichen 'ch' des Fonts 'font' ab dem Bildschirmpunkt
  345.          *  'spot' aus, dabei werden nur die Daten, die speziell dieses
  346.          *  Zeichen, den Font und den angegebenen Punkt betreffen in die
  347.          *  Line-A Variablen eingetragen, daß setzen von Effekten etc.
  348.          *  muß vorher durgeführt werden.
  349.          *  Die Variable 'writingMode' und die Clippingvariablen haben
  350.          *  die gleiche Wirkung wie immer, außerdem werden an speziellen
  351.          *  Textausgabevariablen noch 'scaleAcc', 'scaleFactor', 'scale-
  352.          *  Mode', 'style', 'scaling', 'chup', 'textFg' und 'textBg' aus-
  353.          *  gewertet. Falls man Texteffecte und/oder Scaling benutzt, muß
  354.          *  man 'scratchArea' und 'scratchOff2' noch mit den richtigen
  355.          *  Werten belegen.
  356.          *)
  357.          
  358.  
  359. PROCEDURE ShowMouse (force: BOOLEAN);
  360.  
  361.         (*  Macht den Mauscursor sichtbar. Falls 'force = TRUE' ist, wird
  362.          *  der Cursor auf alle Fälle sichbar, sonst wird er erst sicht-
  363.          *  bar, wenn genauso viele 'ShowMouse' wie vorher 'HideMouse'
  364.          *  durchgeführt worden sind.
  365.          *)
  366.  
  367. PROCEDURE HideMouse;
  368.  
  369.         (*  Versteckt den Mauscursor. Es wird mitgezählt, wie oft die
  370.          *  Procedur aufgerufen wurde (siehe auch 'ShowMouse').
  371.          *)
  372.  
  373. PROCEDURE TransformMouse (newForm: PtrMouseFormDef);
  374.  
  375.         (*  Mit dieser Routine kann man dem Mauscursor ein neues Aussehen
  376.          *  verleihen, dabei ist 'newForm' ein Zeiger auf den Parameter-
  377.          *  block, der das neue Aussehen des Cursors bestimmt.
  378.          *)
  379.                          
  380.                          
  381. TYPE    SpriteFormat    = (vdiFormat, xorFormat);
  382.         SpriteDefBlock  = RECORD
  383.                             offset       : Point;
  384.                             format       : SpriteFormat;
  385.                             backColor    : CARDINAL;
  386.                             foreColor    : CARDINAL;
  387.                             pattern      : ARRAY[0..31] OF CARDINAL;
  388.                           END;
  389.         PtrSpriteDef    = POINTER TO SpriteDefBlock;
  390.         
  391.         (*  Es bedeuten:
  392.          *
  393.          *  'offset'    -- Distanz zwischen dem angegebenen Hot-Spot (Siehe
  394.          *                 'DrawSprite') und dem Pixel, an dem die linke,
  395.          *                 obere Ecke des Sprites erscheint.
  396.          *  'format'    -- Gibt an auf welche Art der Sprite mit dem alten
  397.          *                 Bildschirminhalt verknüpft werden soll.
  398.          *                 Es steht 'Vg' für die Bits des Vordergrundmusters
  399.          *                 und 'Hg' für die des Hintergrundmusters. Das Er-
  400.          *                 gebnis gibt an, welche Farbe sichtbar wird, dabei
  401.          *                 steht 'orginal' für die Farbe des Pixels bevor
  402.          *                 'DrawSprite' aufgerufen wurde. 'xor' stellt die
  403.          *                 logische Exclusiv-Oder Verknüpfung dar.
  404.          *
  405.          *                                 Vg    Hg       Ergebnis
  406.          *
  407.          *                 'vdiFormat':    0     0        orginal
  408.          *                                 0     1        'backColor'
  409.          *                                 1     0        'foreColor'
  410.          *                                 1     1        'foreColor'
  411.          *
  412.          *                 'xorFormat':    0     0        orginal
  413.          *                                 0     1        'backColor'
  414.          *                                 1     0    orginal xor 'foreColor'
  415.          *                                 1     1        'foreColor'
  416.          *
  417.          *  'backColor' -- Hintergrundfarbe
  418.          *  'foreColor' -- Vordergrundfarbe
  419.          *  'pattern'   -- Abwechselnd die Worte für das Hinter- und das
  420.          *                 Vordergrundmuster. Zuerst die oberste Zeile des
  421.          *                 Hintergrundes, darauf die oberste Zeile des Vor-
  422.          *                 dergrundes, dann die zweite Zeile des Hinter-
  423.          *                 grundes und weiter mit der zweiten Zeile des Vor-
  424.          *                 dergrundes usw.
  425.          *)
  426.         
  427.         PtrSpriteBuffer = RECORD
  428.                             CASE (* planes *) :CARDINAL OF
  429.                               1 :  onePlane  : POINTER TO ARRAY[0..73] OF BYTE|
  430.                               2 :  twoPlanes : POINTER TO ARRAY[0..137] OF BYTE|
  431.                               4 :  fourPlanes: POINTER TO ARRAY[0..265] OF BYTE|
  432.                             END;
  433.                           END;
  434.                           
  435.         (*  Dabei gilt, 'onePlane'   für monochrome Darstellung
  436.          *              'twoPlanes'  für 4 farbige Darstellung
  437.          *              'fourPlanes' für 16 farbige Darstellung
  438.          *)
  439.                          
  440. PROCEDURE UndrawSprite (buffer: PtrSpriteBuffer);
  441.  
  442.         (*  Löscht einen Sprite wieder vom Bildschirm, wobei der Hinter-
  443.          *  grund restauriert wird. 'buffer' ist der Speicherbereich, in
  444.          *  den der Hintergrund beim Zeichnen des Sprites gerettet wurde
  445.          *)
  446.  
  447. PROCEDURE DrawSprite (hotSpot: Point;
  448.                       sprite : PtrSpriteDef;
  449.                       buffer : PtrSpriteBuffer);
  450.         
  451.         (*  Diese Procedur zeichnet den Sprite, der durch 'sprite' beschrieben
  452.          *  wird, ab dem Punkt 'hotSpot' auf den Bildschirm. Dabei wird der
  453.          *  ehemalige Inhalt des Bildschirmspeichers (Hintergrund) in den Spei-
  454.          *  cherbereich gerettet, auf den 'buffer' zeigt.
  455.          *)
  456.          
  457.  
  458. TYPE    RasterMode      = RECORD
  459.                             CASE :BOOLEAN OF
  460.                               FALSE :  opaque : BitOperation|
  461.                               TRUE  :  trans  : WritingMode|
  462.                             END
  463.                           END;
  464.  
  465. PROCEDURE CopyRasterForm (sourceMem,
  466.                           destMem    : PtrMemFormDef;
  467.                           sourceStart,
  468.                           sourceEnd,
  469.                           destStart,
  470.                           destEnd    : Point;
  471.                           mode       : RasterMode;
  472.                           setCol,
  473.                           unsetCol   : CARDINAL);
  474.                          
  475.         (*  Diese Routine kopiert einen rechteckigen Bildschirmausschnitt,
  476.          *  dabei ist es nicht nötig, daß der Bildspeicher genau die Größe
  477.          *  eines physikalischen Bildspeichers besitzt (32000 Byte). Viel-
  478.          *  mehr wird die Form des Bildspeichers durch eine Variable vom
  479.          *  Typ 'MemFormDef' bestimmt. 'sourceMem' beschreibt den Quell-
  480.          *  bereich, 'sourceStart' gibt die linke, obere und 'sourceEnd'
  481.          *  die rechte, untere Ecke des Quellrechtecks an. Entsprechend
  482.          *  beschreiben 'destMem', 'destStart' und 'destEnd' den Ziel-
  483.          *  bereich. 'mode' bestimmt die Verknüpfungsart, der Inhalte des
  484.          *  Ziel- und des Quellbereichs. 'setCol' und 'unsetCol' bestimmen
  485.          *  beim 'CopyTransparent'-Modus die Farben im Zielbereich.
  486.          *  Diese Procedur benützt die 'BitBlockTransfer'-Routine.
  487.          *
  488.          *  Man muß zwei Arten des Kopievorgangs unterscheiden. Es ist
  489.          *  'LineAVars.copyTrans':
  490.          *
  491.          *  'FALSE' -- Es muß 'mode.opaque' gesetzt werden.
  492.          *             'setCol' und 'unsetCol' sind wirkungslos 'source
  493.          *             Mem.planes' muß gleich 'destMem.planes' sein.
  494.          *             Entspricht 'VDIRasters.CopyOpaque'.
  495.          *  'TRUE'  -- Es muß 'mode.trans' benutzt werden.
  496.          *             'setCol' legt die Farbe der in 'sourceMem' auf 1
  497.          *             gesetzten Bits fest, 'unsetCol' die der auf 0 ge-
  498.          *             setzten Bits. Dabei muß 'sourceMem.planes=1' sein.
  499.          *             Entspricht 'VDIRasters.CopyTrans'.
  500.          *)
  501.          
  502. PROCEDURE ContourFill (p: Point; color: CARDINAL; useColor: BOOLEAN);
  503.  
  504.         (*  Diese Routine füllt einen Bildschirmbereich von dem Punkt 'p'
  505.          *  ausgehend. Ist 'useColor = TRUE', so wird der Bereich durch
  506.          *  die Farbe 'color' abgegrenzt, sonst durch jede Farbe, außer
  507.          *  der, die dem Punkt 'p' vor dem Funktionsaufruf zugeordnet ist.
  508.          *  Diese Routine benutzt unter anderem die Variable 'seedAbort'.
  509.          *
  510.          *  ACHTUNG: Die Routine ist offiziell nicht dokumentiert. Ihre
  511.          *           Funktionsweise kann sich also bei einer zukünftigen
  512.          *           TOS-Version ändern!
  513.          *)
  514.  
  515. END LineA.
  516.